import type { Request } from "@/types/request";

const BASE_URL = 'http://127.0.0.1:8080';
const TIMEOUT = 30000; // 超时时间（ms:毫秒）

/**
 * 请求函数
 */
export function request<T = any>(options: Request.Options): Promise<Request.Response<T>> {
    return new Promise(async (resolve, reject) => {
        try {
            // 1. 处理URL查询参数（GET/POST均可携带）
            let url = BASE_URL + options.url;
            if (options.params) {
                // 处理数组参数（如eIds），Spring Boot需要多个同名参数
                const params = new URLSearchParams();
                for (const key in options.params) {
                    const value = options.params[key];
                    if (value !== undefined && value !== null) {
                        if (Array.isArray(value)) {
                            // 数组参数：添加多个同名参数
                            value.forEach(item => {
                                params.append(key, String(item));
                            });
                        } else {
                            params.append(key, String(value));
                        }
                    }
                }
                const queryString = params.toString();
                if (queryString) {
                    url += `${url.includes('?') ? '&' : '?'}${queryString}`;
                }
            }

            // 2. 统一处理请求头
            const token = localStorage.getItem('token')
            const headers: Record<string, string> = {
                ...(options.header || {})
            };

            // 只在有token时才添加Authorization头
            if (token) {
                headers['Authorization'] = `Bearer ${token}`
            }

            // 3. 处理POST请求的body数据
            let body: any = undefined;
            const hasBody = (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE');
            if (hasBody && options.data !== undefined && options.data !== null) {
                if ((typeof FormData !== 'undefined' && options.data instanceof FormData) || (options.header && options.header['Content-Type'] === 'multipart/form-data')) {
                    delete headers['Content-Type'];
                    body = options.data;
                } else if (options.header && options.header['Content-Type'] === 'application/json') {
                    headers['Content-Type'] = 'application/json';
                    body = JSON.stringify(options.data);
                } else {
                    headers['Content-Type'] = 'application/x-www-form-urlencoded';
                    const params = new URLSearchParams();
                    for (const key in options.data) {
                        if (options.data[key] !== undefined && options.data[key] !== null) {
                            params.append(key, options.data[key]);
                        }
                    }
                    body = params.toString();
                }
            }

            // 4. 创建超时控制器
            const controller = new AbortController();
            const timeoutId = setTimeout(() => controller.abort(), TIMEOUT);

            // 5. 发送请求
            // 调试：打印请求信息
            console.log('请求URL:', url);
            console.log('请求方法:', options.method || 'GET');
            console.log('请求参数:', options.params);

            const response = await fetch(url, {
                method: options.method || 'GET',
                headers: headers,
                body: body,
                signal: controller.signal
            });

            clearTimeout(timeoutId);

            // 6. 处理响应
            if (!response.ok) {
                try {
                    const errorData = await response.json();
                    alert(errorData.message || `请求失败: ${response.status} ${response.statusText}`);
                    reject(errorData);
                } catch (e) {
                    const errorText = await response.text();
                    alert(`请求失败: ${response.status} ${response.statusText}`);
                    reject({ code: response.status, message: errorText });
                }
                return;
            }

            // 检查响应内容类型
            const contentType = response.headers.get('content-type');
            let responseData;

            if (contentType && contentType.includes('application/json')) {
                // JSON响应
                responseData = await response.json();
            } else {
                // 文本响应（如markdown字符串）
                responseData = await response.text();
            }

            //成功处理请求
            resolve(responseData);
        } catch (error: any) {
            if (error.name === 'AbortError') {
                alert('请求超时，请检查网络连接');
                reject({ code: -1, message: '请求超时', data: null });
            } else if (error.name === 'TypeError' && error.message.includes('fetch')) {
                alert('无法连接到服务器，请确认后端服务已启动（http://127.0.0.1:8080）');
                reject({ code: -1, message: '网络连接失败', data: null });
            } else {
                alert('网络异常，请检查连接');
                reject(error);
            }
        }
    });
}

/**
 * 流式请求函数 - 使用标准 SSE (Server-Sent Events) EventSource API
 * @param options 请求选项
 * @param onMessage 每次接收到数据时的回调函数
 * @param onComplete 流式传输完成时的回调函数
 * @param onError 发生错误时的回调函数
 * @returns cleanup 函数，用于手动关闭连接
 */
export function streamRequest(
    options: Request.Options,
    onMessage: (chunk: string) => void,
    onComplete?: () => void,
    onError?: (error: any) => void
): () => void {
    try {
        // 1. 处理URL查询参数
        let url = BASE_URL + options.url;
        if (options.params) {
            const params = new URLSearchParams(options.params).toString();
            url += `${url.includes('?') ? '&' : '?'}${params}`;
        }

        // 2. 创建 EventSource 连接
        const eventSource = new EventSource(url);

        // 标记是否正常完成
        let isCompleted = false;

        // 3. 监听 message 事件
        eventSource.addEventListener('message', (event) => {
            // 如果已经完成，忽略后续消息
            if (isCompleted) {
                return;
            }

            // 跳过空数据（但不要过滤纯数字字符串）
            if (!event.data) {
                return;
            }

            // 检查是否是空字符串（去除首尾空白后）
            const trimmedData = event.data.trim();
            if (trimmedData === '') {
                return;
            }

            try {
                // 尝试解析 JSON 数据
                const data = JSON.parse(event.data);

                // 检查是否是错误消息
                if (data.type === 'error' || data.error) {
                    const errorMsg = data.message || data.error || '后端处理请求时出现错误';
                    isCompleted = true;
                    eventSource.close();
                    onError?.(new Error(errorMsg));
                    return;
                }

                // 检查是否是结束标记
                if (data.type === 'done') {
                    isCompleted = true;
                    eventSource.close();
                    onComplete?.();
                    return;
                } else if (data.content !== undefined && data.content !== null) {
                    // 提取 content 字段并传递给回调
                    // 确保数字也能正确转换为字符串
                    let contentStr;
                    if (typeof data.content === 'string') {
                        contentStr = data.content;
                    } else if (typeof data.content === 'number') {
                        contentStr = String(data.content);
                    } else {
                        contentStr = String(data.content);
                    }

                    onMessage(contentStr);
                    return;
                } else {
                    // 尝试其他字段
                    if (data.text !== undefined && data.text !== null) {
                        onMessage(String(data.text));
                        return;
                    } else if (data.message !== undefined && data.message !== null) {
                        onMessage(String(data.message));
                        return;
                    }

                    // 如果以上字段都不存在，但数据是原始类型（字符串、数字），直接使用
                    // 这处理了后端可能直接发送字符串或数字的情况
                    if (typeof data === 'string' || typeof data === 'number') {
                        onMessage(String(data));
                        return;
                    }
                }
            } catch (parseError) {
                // 如果 JSON 解析失败，可能是纯文本数据
                // 检查是否是结束标记（纯文本）
                if (trimmedData === '[DONE]' || trimmedData === 'done') {
                    isCompleted = true;
                    eventSource.close();
                    onComplete?.();
                    return;
                }

                // 如果不是结束标记，将原始数据作为文本内容传递
                // 确保数字字符串也能正确传递（不要过滤数字）
                onMessage(event.data);
            }
        });

        // 4. 监听错误事件
        eventSource.addEventListener('error', (event) => {
            // 如果已经正常完成，忽略错误（这是后端关闭连接导致的正常现象）
            if (isCompleted) {
                eventSource.close();
                return;
            }

            // EventSource.CONNECTING = 0, OPEN = 1, CLOSED = 2
            if (eventSource.readyState === EventSource.CLOSED) {
                eventSource.close();
                // 当后端主动关闭连接时，视为正常完成
                if (!isCompleted) {
                    isCompleted = true;
                    onComplete?.();
                }
            } else if (eventSource.readyState === EventSource.CONNECTING) {
                // 正在重连 - 对于我们的流式场景，不需要重连，直接关闭
                eventSource.close();
                if (!isCompleted) {
                    isCompleted = true;
                    onComplete?.();
                }
            } else {
                // OPEN 状态下的错误（通常是后端返回了 HTTP 错误状态码，如 400, 500 等）
                eventSource.close();
                if (!isCompleted) {
                    isCompleted = true;
                    onError?.(new Error('后端服务错误：可能是API配置或参数问题，请查看后端日志'));
                }
            }
        });

        // 5. 监听打开事件
        eventSource.addEventListener('open', () => {
            // 连接已建立，无需特殊处理
        });

        // 6. 返回清理函数
        return () => {
            if (!isCompleted) {
                isCompleted = true;
            }
            eventSource.close();
        };

    } catch (error: any) {
        onError?.(error);
        // 返回空清理函数
        return () => {};
    }
}


